package android.wheel.test;

import android.content.Context;
import android.database.DataSetObserver;
import android.graphics.Canvas;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.GradientDrawable;
import android.graphics.drawable.GradientDrawable.Orientation;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
import android.view.animation.Interpolator;
import android.wheel.test.adapter.WheelViewAdapter;
import android.widget.LinearLayout;

import com.yunhuajinfu.R;

import java.util.LinkedList;
import java.util.List;

/**
 * Numeric wheel view.
 * 
 * @author Yuri Kanivets
 */
public class WheelView extends View {

        /** Top and bottom shadows colors */
        private static final int[] SHADOWS_COLORS = new int[] { 0xFF111111,
                        0x00AAAAAA, 0x00AAAAAA };

        /** Top and bottom items offset (to hide that) */
        private static final int ITEM_OFFSET_PERCENT = 10;

        /** Left and right padding value */
        private static final int PADDING = 0;

        /** Default count of visible items */
        private static final int DEF_VISIBLE_ITEMS = 5;

        // Wheel Values
        private int currentItem = 0;
        
        // Count of visible items
        private int visibleItems = DEF_VISIBLE_ITEMS;
        
        // Item height
        private int itemHeight = 0;

        // Center Line
        private Drawable centerDrawable;

        // Shadows drawables
        private GradientDrawable topShadow;
        private GradientDrawable bottomShadow;

        // Scrolling
        private WheelScroller scroller;
        private boolean isScrollingPerformed; 
        private int scrollingOffset;

        // Cyclic
        boolean isCyclic = false;
        
        // Items layout
        private LinearLayout itemsLayout;
        
        // The number of first item in layout
        private int firstItem;

        // View adapter
        private WheelViewAdapter viewAdapter;
        
        // Recycle
        private WheelRecycle recycle = new WheelRecycle(this);

        // Listeners
        private List<OnWheelChangedListener> changingListeners = new LinkedList<OnWheelChangedListener>();
        private List<OnWheelScrollListener> scrollingListeners = new LinkedList<OnWheelScrollListener>();
        private List<OnWheelClickedListener> clickingListeners = new LinkedList<OnWheelClickedListener>();

        /**
         * Constructor
         */
        public WheelView(Context context, AttributeSet attrs, int defStyle) {
                super(context, attrs, defStyle);
                initData(context);
        }

        /**
         * Constructor
         */
        public WheelView(Context context, AttributeSet attrs) {
                super(context, attrs);
                initData(context);
        }

        /**
         * Constructor
         */
        public WheelView(Context context) {
                super(context);
                initData(context);
        }
        
        /**
         * Initializes class data
         * @param context the context
         */
        private void initData(Context context) {
            scroller = new WheelScroller(getContext(), scrollingListener);
        }
        
        // Scrolling listener
        WheelScroller.ScrollingListener scrollingListener = new WheelScroller.ScrollingListener() {
        public void onStarted() {
            isScrollingPerformed = true;
            notifyScrollingListenersAboutStart();
        }
        
        public void onScroll(int distance) {
            doScroll(distance);
            
            int height = getHeight();
            if (scrollingOffset > height) {
                scrollingOffset = height;
                scroller.stopScrolling();
            } else if (scrollingOffset < -height) {
                scrollingOffset = -height;
                scroller.stopScrolling();
            }
        }
        
        public void onFinished() {
            if (isScrollingPerformed) {
                notifyScrollingListenersAboutEnd();
                isScrollingPerformed = false;
            }
            
            scrollingOffset = 0;
            invalidate();
        }

        public void onJustify() {
            if (Math.abs(scrollingOffset) > WheelScroller.MIN_DELTA_FOR_SCROLLING) {
                scroller.scroll(scrollingOffset, 0);
            }
        }
    };
        
        /**
         * Set the the specified scrolling interpolator
         * @param interpolator the interpolator
         */
        public void setInterpolator(Interpolator interpolator) {
                scroller.setInterpolator(interpolator);
        }
        
        /**
         * Gets count of visible items
         * 
         * @return the count of visible items
         */
        public int getVisibleItems() {
                return visibleItems;
        }

        /**
         * Sets the desired count of visible items.
         * Actual amount of visible items depends on wheel layout parameters.
         * To apply changes and rebuild view call measure(). 
         * 
         * @param count the desired count for visible items
         */
        public void setVisibleItems(int count) {
                visibleItems = count;
        }

        /**
         * Gets view adapter
         * @return the view adapter
         */
        public WheelViewAdapter getViewAdapter() {
                return viewAdapter;
        }

        // Adapter listener
    private DataSetObserver dataObserver = new DataSetObserver() {
        @Override
        public void onChanged() {
            invalidateWheel(false);
        }

        @Override
        public void onInvalidated() {
            invalidateWheel(true);
        }
    };

        /**
         * Sets view adapter. Usually new adapters contain different views, so
         * it needs to rebuild view by calling measure().
         *  
         * @param viewAdapter the view adapter
         */
        public void setViewAdapter(WheelViewAdapter viewAdapter) {
            if (this.viewAdapter != null) {
                this.viewAdapter.unregisterDataSetObserver(dataObserver);
            }
        this.viewAdapter = viewAdapter;
        if (this.viewAdapter != null) {
            this.viewAdapter.registerDataSetObserver(dataObserver);
        }
        
        invalidateWheel(true);
        }
        
        /**
         * Adds wheel changing listener
         * @param listener the listener 
         */
        public void addChangingListener(OnWheelChangedListener listener) {
                changingListeners.add(listener);
        }

        /**
         * Removes wheel changing listener
         * @param listener the listener
         */
        public void removeChangingListener(OnWheelChangedListener listener) {
                changingListeners.remove(listener);
        }
        
        /**
         * Notifies changing listeners
         * @param oldValue the old wheel value
         * @param newValue the new wheel value
         */
        protected void notifyChangingListeners(int oldValue, int newValue) {
                for (OnWheelChangedListener listener : changingListeners) {
                        listener.onChanged(this, oldValue, newValue);
                }
        }

        /**
         * Adds wheel scrolling listener
         * @param listener the listener 
         */
        public void addScrollingListener(OnWheelScrollListener listener) {
                scrollingListeners.add(listener);
        }

        /**
         * Removes wheel scrolling listener
         * @param listener the listener
         */
        public void removeScrollingListener(OnWheelScrollListener listener) {
                scrollingListeners.remove(listener);
        }
        
        /**
         * Notifies listeners about starting scrolling
         */
        protected void notifyScrollingListenersAboutStart() {
                for (OnWheelScrollListener listener : scrollingListeners) {
                        listener.onScrollingStarted(this);
                }
        }

        /**
         * Notifies listeners about ending scrolling
         */
        protected void notifyScrollingListenersAboutEnd() {
                for (OnWheelScrollListener listener : scrollingListeners) {
                        listener.onScrollingFinished(this);
                }
        }

    /**
     * Adds wheel clicking listener
     * @param listener the listener 
     */
    public void addClickingListener(OnWheelClickedListener listener) {
        clickingListeners.add(listener);
    }

    /**
     * Removes wheel clicking listener
     * @param listener the listener
     */
    public void removeClickingListener(OnWheelClickedListener listener) {
        clickingListeners.remove(listener);
    }
    
    /**
     * Notifies listeners about clicking
     */
    protected void notifyClickListenersAboutClick(int item) {
        for (OnWheelClickedListener listener : clickingListeners) {
            listener.onItemClicked(this, item);
        }
    }

        /**
         * Gets current value
         * 
         * @return the current value
         */
        public int getCurrentItem() {
                return currentItem;
        }

        /**
         * Sets the current item. Does nothing when index is wrong.
         * 
         * @param index the item index
         * @param animated the animation flag
         */
        public void setCurrentItem(int index, boolean animated) {
                if (viewAdapter == null || viewAdapter.getItemsCount() == 0) {
                        return; // throw?
                }
                
                int itemCount = viewAdapter.getItemsCount();
                if (index < 0 || index >= itemCount) {
                        if (isCyclic) {
                                while (index < 0) {
                                        index += itemCount;
                                }
                                index %= itemCount;
                        } else{
                                return; // throw?
                        }
                }
                if (index != currentItem) {
                        if (animated) {
                            int itemsToScroll = index - currentItem;
                            if (isCyclic) {
                                int scroll = itemCount + Math.min(index, currentItem) - Math.max(index, currentItem);
                                if (scroll < Math.abs(itemsToScroll)) {
                                    itemsToScroll = itemsToScroll < 0 ? scroll : -scroll;
                                }
                            }
                                scroll(itemsToScroll, 0);
                        } else {
                                scrollingOffset = 0;
                        
                                int old = currentItem;
                                currentItem = index;
                        
                                notifyChangingListeners(old, currentItem);
                        
                                invalidate();
                        }
                }
        }

        /**
         * Sets the current item w/o animation. Does nothing when index is wrong.
         * 
         * @param index the item index
         */
        public void setCurrentItem(int index) {
            setCurrentItem(index, false);
        }       
        
        /**
         * Tests if wheel is cyclic. That means before the 1st item there is shown the last one
         * @return true if wheel is cyclic
         */
        public boolean isCyclic() {
                return isCyclic;
        }

        /**
         * Set wheel cyclic flag
         * @param isCyclic the flag to set
         */
        public void setCyclic(boolean isCyclic) {
                this.isCyclic = isCyclic;
                invalidateWheel(false);
        }
        
        /**
         * Invalidates wheel
         * @param clearCaches if true then cached views will be clear
         */
    public void invalidateWheel(boolean clearCaches) {
        if (clearCaches) {
            recycle.clearAll();
            if (itemsLayout != null) {
                itemsLayout.removeAllViews();
            }
            scrollingOffset = 0;
        } else if (itemsLayout != null) {
            // cache all items
                recycle.recycleItems(itemsLayout, firstItem, new ItemsRange());         
        }
        
        invalidate();
        }

        /**
         * Initializes resources
         */
        private void initResourcesIfNecessary() {
                if (centerDrawable == null) {
                        centerDrawable = getContext().getResources().getDrawable(R.drawable.wheel_val);
                }

                if (topShadow == null) {
                        topShadow = new GradientDrawable(Orientation.TOP_BOTTOM, SHADOWS_COLORS);
                }

                if (bottomShadow == null) {
                        bottomShadow = new GradientDrawable(Orientation.BOTTOM_TOP, SHADOWS_COLORS);
                }

                setBackgroundResource(R.drawable.wheel_bg);
        }
        
        /**
         * Calculates desired height for layout
         * 
         * @param layout
         *            the source layout
         * @return the desired layout height
         */
        private int getDesiredHeight(LinearLayout layout) {
                if (layout != null && layout.getChildAt(0) != null) {
                        itemHeight = layout.getChildAt(0).getMeasuredHeight();
                }

                int desired = itemHeight * visibleItems - itemHeight * ITEM_OFFSET_PERCENT / 50;

                return Math.max(desired, getSuggestedMinimumHeight());
        }

        /**
         * Returns height of wheel item
         * @return the item height
         */
        private int getItemHeight() {
                if (itemHeight != 0) {
                        return itemHeight;
                }
                
                if (itemsLayout != null && itemsLayout.getChildAt(0) != null) {
                        itemHeight = itemsLayout.getChildAt(0).getHeight();
                        return itemHeight;
                }
                
                return getHeight() / visibleItems;
        }

        /**
         * Calculates control width and creates text layouts
         * @param widthSize the input layout width
         * @param mode the layout mode
         * @return the calculated control width
         */
        private int calculateLayoutWidth(int widthSize, int mode) {
                initResourcesIfNecessary();

                // TODO: make it static
                itemsLayout.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
            itemsLayout.measure(MeasureSpec.makeMeasureSpec(widthSize, MeasureSpec.UNSPECIFIED), 
                        MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
                int width = itemsLayout.getMeasuredWidth();

                if (mode == MeasureSpec.EXACTLY) {
                        width = widthSize;
                } else {
                        width += 2 * PADDING;

                        // Check against our minimum width
                        width = Math.max(width, getSuggestedMinimumWidth());

                        if (mode == MeasureSpec.AT_MOST && widthSize < width) {
                                width = widthSize;
                        }
                }
                
        itemsLayout.measure(MeasureSpec.makeMeasureSpec(width - 2 * PADDING, MeasureSpec.EXACTLY), 
                MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));

                return width;
        }

        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                int widthMode = MeasureSpec.getMode(widthMeasureSpec);
                int heightMode = MeasureSpec.getMode(heightMeasureSpec);
                int widthSize = MeasureSpec.getSize(widthMeasureSpec);
                int heightSize = MeasureSpec.getSize(heightMeasureSpec);

                buildViewForMeasuring();
                
                int width = calculateLayoutWidth(widthSize, widthMode);

                int height;
                if (heightMode == MeasureSpec.EXACTLY) {
                        height = heightSize;
                } else {
                        height = getDesiredHeight(itemsLayout);

                        if (heightMode == MeasureSpec.AT_MOST) {
                                height = Math.min(height, heightSize);
                        }
                }

                setMeasuredDimension(width, height);
        }
        
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        layout(r - l, b - t);
    }

    /**
     * Sets layouts width and height
     * @param width the layout width
     * @param height the layout height
     */
    private void layout(int width, int height) {
                int itemsWidth = width - 2 * PADDING;
                
                itemsLayout.layout(0, 0, itemsWidth, height);
    }

        @Override
        protected void onDraw(Canvas canvas) {
                super.onDraw(canvas);
                
                if (viewAdapter != null && viewAdapter.getItemsCount() > 0) {
                updateView();

                drawItems(canvas);
                drawCenterRect(canvas);
                }
                
        drawShadows(canvas);
        }

        /**
         * Draws shadows on top and bottom of control
         * @param canvas the canvas for drawing
         */
        private void drawShadows(Canvas canvas) {
                int height = (int)(1.5 * getItemHeight());
                topShadow.setBounds(0, 0, getWidth(), height);
                topShadow.draw(canvas);

                bottomShadow.setBounds(0, getHeight() - height, getWidth(), getHeight());
                bottomShadow.draw(canvas);
        }

        /**
         * Draws items
         * @param canvas the canvas for drawing
         */
        private void drawItems(Canvas canvas) {
                canvas.save();
                
                int top = (currentItem - firstItem) * getItemHeight() + (getItemHeight() - getHeight()) / 2;
                canvas.translate(PADDING, - top + scrollingOffset);
                
                itemsLayout.draw(canvas);

                canvas.restore();
        }

        /**
         * Draws rect for current value
         * @param canvas the canvas for drawing
         */
        private void drawCenterRect(Canvas canvas) {
                int center = getHeight() / 2;
                int offset = (int) (getItemHeight() / 2 * 1.2);
                centerDrawable.setBounds(0, center - offset, getWidth(), center + offset);
                centerDrawable.draw(canvas);
        }

        @Override
        public boolean onTouchEvent(MotionEvent event) {
                if (!isEnabled() || getViewAdapter() == null) {
                        return true;
                }
                
                switch (event.getAction()) {
                    case MotionEvent.ACTION_MOVE:
                        if (getParent() != null) {
                            getParent().requestDisallowInterceptTouchEvent(true);
                        }
                        break;
                        
                    case MotionEvent.ACTION_UP:
                        if (!isScrollingPerformed) {
                            int distance = (int) event.getY() - getHeight() / 2;
                            if (distance > 0) {
                                distance += getItemHeight() / 2;
                            } else {
                        distance -= getItemHeight() / 2;
                            }
                            int items = distance / getItemHeight();
                            if (items != 0 && isValidItemIndex(currentItem + items)) {
                            notifyClickListenersAboutClick(currentItem + items);
                            }
                        }
                        break;
                }

                return scroller.onTouchEvent(event);
        }
        
        /**
         * Scrolls the wheel
         * @param delta the scrolling value
         */
        private void doScroll(int delta) {
                scrollingOffset += delta;
                
                int itemHeight = getItemHeight();
                int count = scrollingOffset / itemHeight;

                int pos = currentItem - count;
                int itemCount = viewAdapter.getItemsCount();
                
            int fixPos = scrollingOffset % itemHeight;
            if (Math.abs(fixPos) <= itemHeight / 2) {
                fixPos = 0;
            }
                if (isCyclic && itemCount > 0) {
                    if (fixPos > 0) {
                        pos--;
                count++;
                    } else if (fixPos < 0) {
                        pos++;
                        count--;
                    }
                        // fix position by rotating
                        while (pos < 0) {
                                pos += itemCount;
                        }
                        pos %= itemCount;
                } else {
                        // 
                        if (pos < 0) {
                                count = currentItem;
                                pos = 0;
                        } else if (pos >= itemCount) {
                                count = currentItem - itemCount + 1;
                                pos = itemCount - 1;
                        } else if (pos > 0 && fixPos > 0) {
                pos--;
                count++;
            } else if (pos < itemCount - 1 && fixPos < 0) {
                pos++;
                count--;
            }
                }
                
                int offset = scrollingOffset;
                if (pos != currentItem) {
                        setCurrentItem(pos, false);
                } else {
                        invalidate();
                }
                
                // update offset
                scrollingOffset = offset - count * itemHeight;
                if (scrollingOffset > getHeight()) {
                        scrollingOffset = scrollingOffset % getHeight() + getHeight();
                }
        }
                
        /**
         * Scroll the wheel
         * @param
         * @param time scrolling duration
         */
        public void scroll(int itemsToScroll, int time) {
                int distance = itemsToScroll * getItemHeight() - scrollingOffset;
        scroller.scroll(distance, time);
        }
        
        /**
         * Calculates range for wheel items
         * @return the items range
         */
        private ItemsRange getItemsRange() {
        if (getItemHeight() == 0) {
            return null;
        }
        
                int first = currentItem;
                int count = 1;
                
                while (count * getItemHeight() < getHeight()) {
                        first--;
                        count += 2; // top + bottom items
                }
                
                if (scrollingOffset != 0) {
                        if (scrollingOffset > 0) {
                                first--;
                        }
                        count++;
                        
                        // process empty items above the first or below the second
                        int emptyItems = scrollingOffset / getItemHeight();
                        first -= emptyItems;
                        count += Math.asin(emptyItems);
                }
                return new ItemsRange(first, count);
        }
        
        /**
         * Rebuilds wheel items if necessary. Caches all unused items.
         * 
         * @return true if items are rebuilt
         */
        private boolean rebuildItems() {
                boolean updated = false;
                ItemsRange range = getItemsRange();
                if (itemsLayout != null) {
                        int first = recycle.recycleItems(itemsLayout, firstItem, range);
                        updated = firstItem != first;
                        firstItem = first;
                } else {
                        createItemsLayout();
                        updated = true;
                }
                
                if (!updated) {
                        updated = firstItem != range.getFirst() || itemsLayout.getChildCount() != range.getCount();
                }
                
                if (firstItem > range.getFirst() && firstItem <= range.getLast()) {
                        for (int i = firstItem - 1; i >= range.getFirst(); i--) {
                                if (!addViewItem(i, true)) {
                                    break;
                                }
                                firstItem = i;
                        }                       
                } else {
                    firstItem = range.getFirst();
                }
                
                int first = firstItem;
                for (int i = itemsLayout.getChildCount(); i < range.getCount(); i++) {
                        if (!addViewItem(firstItem + i, false) && itemsLayout.getChildCount() == 0) {
                            first++;
                        }
                }
                firstItem = first;
                
                return updated;
        }
        
        /**
         * Updates view. Rebuilds items and label if necessary, recalculate items sizes.
         */
        private void updateView() {
                if (rebuildItems()) {
                        calculateLayoutWidth(getWidth(), MeasureSpec.EXACTLY);
                        layout(getWidth(), getHeight());
                }
        }

        /**
         * Creates item layouts if necessary
         */
        private void createItemsLayout() {
                if (itemsLayout == null) {
                        itemsLayout = new LinearLayout(getContext());
                        itemsLayout.setOrientation(LinearLayout.VERTICAL);
                }
        }

        /**
         * Builds view for measuring
         */
        private void buildViewForMeasuring() {
                // clear all items
                if (itemsLayout != null) {
                        recycle.recycleItems(itemsLayout, firstItem, new ItemsRange());                 
                } else {
                        createItemsLayout();
                }
                
                // add views
                int addItems = visibleItems / 2;
                for (int i = currentItem + addItems; i >= currentItem - addItems; i--) {
                        if (addViewItem(i, true)) {
                            firstItem = i;
                        }
                }
        }

        /**
         * Adds view for item to items layout
         * @param index the item index
         * @param first the flag indicates if view should be first
         * @return true if corresponding item exists and is added
         */
        private boolean addViewItem(int index, boolean first) {
                View view = getItemView(index);
                if (view != null) {
                        if (first) {
                                itemsLayout.addView(view, 0);
                        } else {
                                itemsLayout.addView(view);
                        }
                        
                        return true;
                }
                
                return false;
        }
        
        /**
         * Checks whether intem index is valid
         * @param index the item index
         * @return true if item index is not out of bounds or the wheel is cyclic
         */
        private boolean isValidItemIndex(int index) {
            return viewAdapter != null && viewAdapter.getItemsCount() > 0 &&
                (isCyclic || index >= 0 && index < viewAdapter.getItemsCount());
        }
        
        /**
         * Returns view for specified item
         * @param index the item index
         * @return item view or empty view if index is out of bounds
         */
    private View getItemView(int index) {
                if (viewAdapter == null || viewAdapter.getItemsCount() == 0) {
                        return null;
                }
                int count = viewAdapter.getItemsCount();
                if (!isValidItemIndex(index)) {
                        return viewAdapter.getEmptyItem(recycle.getEmptyItem(), itemsLayout);
                } else {
                        while (index < 0) {
                                index = count + index;
                        }
                }
                
                index %= count;
                return viewAdapter.getItem(index, recycle.getItem(), itemsLayout);
        }
        
        /**
         * Stops scrolling
         */
        public void stopScrolling() {
            scroller.stopScrolling();
        }
}
